home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1997 July: Mac OS SDK / Dev.CD Jul 97 SDK1.toast / Development Kits (Disc 1) / Interfaces&Libraries / Interfaces / PInterfaces / MIDI.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  17.4 KB  |  528 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        MIDI.p
  3.  
  4.      Contains:    MIDI Manager Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT MIDI;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __MIDI__}
  30. {$SETC __MIDI__ := 1}
  31.  
  32. {$I+}
  33. {$SETC MIDIIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __ERRORS__}
  38. {$I Errors.p}
  39. {$ENDC}
  40. {    ConditionalMacros.p                                            }
  41.  
  42. {$IFC UNDEFINED __TYPES__}
  43. {$I Types.p}
  44. {$ENDC}
  45.  
  46. {$IFC UNDEFINED __MIXEDMODE__}
  47. {$I MixedMode.p}
  48. {$ENDC}
  49.  
  50. {$PUSH}
  51. {$ALIGN MAC68K}
  52. {$LibExport+}
  53. {
  54.                         * * *  N O T E  * * * 
  55.  
  56.     This file has been updated to include MIDI 2.0 interfaces.  
  57.     
  58.     The MIDI 2.0 interfaces were developed for the classic 68K runtime.
  59.     Since then, Apple has created the PowerPC and CFM 68K runtimes.
  60.     Currently, the extra functions in MIDI 2.0 are not in InterfaceLib
  61.     and thus not callable from PowerPC and CFM 68K runtimes (you'll
  62.     get a linker error).  
  63. }
  64.  
  65. CONST
  66.     midiMaxNameLen                = 31;                            {maximum number of characters in port and client names}
  67. { Time formats }
  68.     midiFormatMSec                = 0;                            {milliseconds}
  69.     midiFormatBeats                = 1;                            {beats}
  70.     midiFormat24fpsBit            = 2;                            {24 frames/sec.}
  71.     midiFormat25fpsBit            = 3;                            {25 frames/sec.}
  72.     midiFormat30fpsDBit            = 4;                            {30 frames/sec. drop-frame}
  73.     midiFormat30fpsBit            = 5;                            {30 frames/sec.}
  74.     midiFormat24fpsQF            = 6;                            {24 frames/sec. longInt format }
  75.     midiFormat25fpsQF            = 7;                            {25 frames/sec. longInt format }
  76.     midiFormat30fpsDQF            = 8;                            {30 frames/sec. drop-frame longInt format }
  77.     midiFormat30fpsQF            = 9;                            {30 frames/sec. longInt format }
  78.     midiInternalSync            = 0;                            {internal sync}
  79.     midiExternalSync            = 1;                            {external sync}
  80. { Port types}
  81.     midiPortTypeTime            = 0;                            {time port}
  82.     midiPortTypeInput            = 1;                            {input port}
  83.     midiPortTypeOutput            = 2;                            {output port}
  84.     midiPortTypeTimeInv            = 3;                            {invisible time port}
  85.     midiPortInvisible            = $8000;                        {logical OR this to other types to make invisible ports}
  86.     midiPortTypeMask            = $0007;                        {logical AND with this to convert new port types to old,
  87.                                       ie. to strip the property bits}
  88. { OffsetTimes  }
  89.     midiGetEverything            = $7FFFFFFF;                    {get all packets, regardless of time stamps}
  90.     midiGetNothing                = $80000000;                    {get no packets, regardless of time stamps}
  91.     midiGetCurrent                = $00000000;                    {get current packets only}
  92.  
  93. {    MIDI data and messages are passed in MIDIPacket records (see below).
  94.     The first byte of every MIDIPacket contains a set of flags
  95.  
  96.     bits 0-1    00 = new MIDIPacket, not continued
  97.                      01 = begining of continued MIDIPacket
  98.                      10 = end of continued MIDIPacket
  99.                      11 = continuation
  100.     bits 2-3     reserved
  101.  
  102.     bits 4-6      000 = packet contains MIDI data
  103.  
  104.                   001 = packet contains MIDI Manager message
  105.  
  106.     bit 7         0 = MIDIPacket has valid stamp
  107.                   1 = stamp with current clock
  108. }
  109.     midiContMask                = $03;
  110.     midiNoCont                    = $00;
  111.     midiStartCont                = $01;
  112.     midiMidCont                    = $03;
  113.     midiEndCont                    = $02;
  114.     midiTypeMask                = $70;
  115.     midiMsgType                    = $00;
  116.     midiMgrType                    = $10;
  117.     midiTimeStampMask            = $80;
  118.     midiTimeStampCurrent        = $80;
  119.     midiTimeStampValid            = $00;
  120. { MIDIPacket command words (the first word in the data field for midiMgrType messages) }
  121.     midiOverflowErr                = $0001;
  122.     midiSCCErr                    = $0002;
  123.     midiPacketErr                = $0003;
  124. {all command words less than this value are error indicators}
  125.     midiMaxErr                    = $00FF;
  126. { Valid results to be returned by readHooks }
  127.     midiKeepPacket                = 0;
  128.     midiMorePacket                = 1;
  129.     midiNoMorePacket            = 2;
  130.     midiHoldPacket                = 3;
  131. { Driver calls }
  132.     midiOpenDriver                = 1;
  133.     midiCloseDriver                = 2;
  134.  
  135.     mdvrAbortNotesOff            = 0;                            {abort previous mdvrNotesOff request}
  136.     mdvrChanNotesOff            = 1;                            {generate channel note off messages}
  137.     mdvrAllNotesOff                = 2;                            {generate all note off messages}
  138.     mdvrStopOut                    = 0;                            {stop calling MDVROut temporarily}
  139.     mdvrStartOut                = 1;                            {resume calling MDVROut}
  140.  
  141.  
  142. TYPE
  143.     MIDIPacket = PACKED RECORD
  144.         flags:                    UInt8;
  145.         len:                    UInt8;
  146.         tStamp:                    LONGINT;
  147.         data:                    ARRAY [0..248] OF UInt8;
  148.     END;
  149.  
  150.     MIDIPacketPtr = ^MIDIPacket;
  151.  
  152.     MIDIReadHookProcPtr = ProcPtr;  { FUNCTION MIDIReadHook(myPacket: MIDIPacketPtr; myRefCon: LONGINT): INTEGER; }
  153.     MIDITimeProcPtr = ProcPtr;  { PROCEDURE MIDITime(curTime: LONGINT; myRefCon: LONGINT); }
  154.     MIDIConnectionProcPtr = ProcPtr;  { PROCEDURE MIDIConnection(refnum: INTEGER; refcon: LONGINT; portType: INTEGER; clientID: OSType; portID: OSType; connect: BOOLEAN; direction: INTEGER); }
  155.     MDVRCommProcPtr = ProcPtr;  { FUNCTION MDVRComm(refnum: INTEGER; request: INTEGER; refCon: LONGINT): LONGINT; }
  156.     MDVRTimeCodeProcPtr = ProcPtr;  { PROCEDURE MDVRTimeCode(refnum: INTEGER; newFormat: INTEGER; refCon: LONGINT); }
  157.     MDVRReadProcPtr = ProcPtr;  { PROCEDURE MDVRRead(midiChars: CStringPtr; length: INTEGER; refCon: LONGINT); }
  158.     MIDIReadHookUPP = UniversalProcPtr;
  159.     MIDITimeUPP = UniversalProcPtr;
  160.     MIDIConnectionUPP = UniversalProcPtr;
  161.     MDVRCommUPP = UniversalProcPtr;
  162.     MDVRTimeCodeUPP = UniversalProcPtr;
  163.     MDVRReadUPP = UniversalProcPtr;
  164.  
  165.     MIDIClkInfo = RECORD
  166.         syncType:                INTEGER;                                {synchronization external/internal}
  167.         curTime:                LONGINT;                                {current value of port's clock}
  168.         format:                    INTEGER;                                {time code format}
  169.     END;
  170.  
  171.     MIDIIDRec = RECORD
  172.         clientID:                OSType;
  173.         portID:                    OSType;
  174.     END;
  175.  
  176.     MIDIPortInfo = RECORD
  177.         portType:                INTEGER;                                {type of port}
  178.         timeBase:                MIDIIDRec;                                {MIDIIDRec for time base}
  179.         numConnects:            INTEGER;                                {number of connections}
  180.         cList:                    ARRAY [0..0] OF MIDIIDRec;                {ARRAY [1..numConnects] of MIDIIDRec}
  181.     END;
  182.  
  183.     MIDIPortInfoPtr = ^MIDIPortInfo;
  184.     MIDIPortInfoHdl = ^MIDIPortInfoPtr;
  185.     MIDIPortInfoHandle = ^MIDIPortInfoPtr;
  186.  
  187.     MIDIPortParams = RECORD
  188.         portID:                    OSType;                                    {ID of port, unique within client}
  189.         portType:                INTEGER;                                {Type of port - input, output, time, etc.}
  190.         timeBase:                INTEGER;                                {refnum of time base, 0 if none}
  191.         offsetTime:                LONGINT;                                {offset for current time stamps}
  192.         readHook:                MIDIReadHookUPP;                        {routine to call when input data is valid}
  193.         refCon:                    LONGINT;                                {refcon for port (for client use)}
  194.         initClock:                MIDIClkInfo;                            {initial settings for a time base}
  195.         name:                    Str255;                                    {name of the port, This is a real live string, not a ptr.}
  196.     END;
  197.  
  198.     MIDIPortParamsPtr = ^MIDIPortParams;
  199.  
  200.     MIDIIDList = RECORD
  201.         numIDs:                    INTEGER;
  202.         list:                    ARRAY [0..0] OF OSType;
  203.     END;
  204.  
  205.     MIDIIDListPtr = ^MIDIIDList;
  206.     MIDIIDListHdl = ^MIDIIDListPtr;
  207.     MIDIIDListHandle = ^MIDIIDListPtr;
  208.  
  209. { MDVR Control structs}
  210.     MDVRInCtlRec = RECORD
  211.         timeCodeClock:            INTEGER;                                {refnum of time base for time code}
  212.         timeCodeFormat:            INTEGER;                                {format of time code output}
  213.         readProc:                MDVRReadUPP;                            {proc to call with intput characters}
  214.         commProc:                MDVRCommUPP;                            {proc to call for handshaking}
  215.         refCon:                    LONGINT;                                {refCon passed to readProc, commProc}
  216.     END;
  217.  
  218.     MDVRInCtlPtr = ^MDVRInCtlRec;
  219.  
  220.     MDVROutCtlRec = RECORD
  221.         timeCodeClock:            INTEGER;                                {time base driven by time code}
  222.         timeCodeFormat:            INTEGER;                                {format of time code to listen to}
  223.         timeCodeProc:            MDVRTimeCodeUPP;                        {proc called on time code fmt change}
  224.         commProc:                MDVRCommUPP;                            {proc called for handshaking}
  225.         refCon:                    LONGINT;                                {refCon passed to timeCodeProc}
  226.         timeCodeFilter:            BOOLEAN;                                {filter time code if true}
  227.         padding:                SInt8; (* UInt8 *)                        {unused pad byte}
  228.         midiMsgTicks:            LONGINT;                                {value of Ticks when MIDI msg rcvd}
  229.         timeCodeTicks:            LONGINT;                                {value of Ticks when time code rcvd}
  230.     END;
  231.  
  232.     MDVROutCtlPtr = ^MDVROutCtlRec;
  233.  
  234.     MDVRPtr = Ptr;
  235.  
  236. { MIDIVersion() return a NumVersion}
  237.  
  238. FUNCTION MIDIVersion: LONGINT;
  239.     {$IFC NOT GENERATINGCFM}
  240.     INLINE $203C, $0000, 4, $A800;
  241.     {$ENDC}
  242. FUNCTION MIDISignIn(clientID: OSType; refCon: LONGINT; icon: Handle; name: ConstStr255Param): OSErr;
  243.     {$IFC NOT GENERATINGCFM}
  244.     INLINE $203C, $0004, 4, $A800;
  245.     {$ENDC}
  246. PROCEDURE MIDISignOut(clientID: OSType);
  247.     {$IFC NOT GENERATINGCFM}
  248.     INLINE $203C, $0008, 4, $A800;
  249.     {$ENDC}
  250. FUNCTION MIDIGetClients: MIDIIDListHandle;
  251.     {$IFC NOT GENERATINGCFM}
  252.     INLINE $203C, $000C, 4, $A800;
  253.     {$ENDC}
  254. PROCEDURE MIDIGetClientName(clientID: OSType; VAR name: Str255);
  255.     {$IFC NOT GENERATINGCFM}
  256.     INLINE $203C, $0010, 4, $A800;
  257.     {$ENDC}
  258. PROCEDURE MIDISetClientName(clientID: OSType; name: ConstStr255Param);
  259.     {$IFC NOT GENERATINGCFM}
  260.     INLINE $203C, $0014, 4, $A800;
  261.     {$ENDC}
  262. FUNCTION MIDIGetPorts(clientID: OSType): MIDIIDListHandle;
  263.     {$IFC NOT GENERATINGCFM}
  264.     INLINE $203C, $0018, 4, $A800;
  265.     {$ENDC}
  266. FUNCTION MIDIAddPort(clientID: OSType; BufSize: INTEGER; VAR refnum: INTEGER; init: MIDIPortParamsPtr): OSErr;
  267.     {$IFC NOT GENERATINGCFM}
  268.     INLINE $203C, $001C, 4, $A800;
  269.     {$ENDC}
  270. FUNCTION MIDIGetPortInfo(clientID: OSType; portID: OSType): MIDIPortInfoHandle;
  271.     {$IFC NOT GENERATINGCFM}
  272.     INLINE $203C, $0020, 4, $A800;
  273.     {$ENDC}
  274. FUNCTION MIDIConnectData(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  275.     {$IFC NOT GENERATINGCFM}
  276.     INLINE $203C, $0024, 4, $A800;
  277.     {$ENDC}
  278. FUNCTION MIDIUnConnectData(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  279.     {$IFC NOT GENERATINGCFM}
  280.     INLINE $203C, $0028, 4, $A800;
  281.     {$ENDC}
  282. FUNCTION MIDIConnectTime(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  283.     {$IFC NOT GENERATINGCFM}
  284.     INLINE $203C, $002C, 4, $A800;
  285.     {$ENDC}
  286. FUNCTION MIDIUnConnectTime(srcClID: OSType; srcPortID: OSType; dstClID: OSType; dstPortID: OSType): OSErr;
  287.     {$IFC NOT GENERATINGCFM}
  288.     INLINE $203C, $0030, 4, $A800;
  289.     {$ENDC}
  290. PROCEDURE MIDIFlush(refnum: INTEGER);
  291.     {$IFC NOT GENERATINGCFM}
  292.     INLINE $203C, $0034, 4, $A800;
  293.     {$ENDC}
  294. FUNCTION MIDIGetReadHook(refnum: INTEGER): ProcPtr;
  295.     {$IFC NOT GENERATINGCFM}
  296.     INLINE $203C, $0038, 4, $A800;
  297.     {$ENDC}
  298. PROCEDURE MIDISetReadHook(refnum: INTEGER; hook: ProcPtr);
  299.     {$IFC NOT GENERATINGCFM}
  300.     INLINE $203C, $003C, 4, $A800;
  301.     {$ENDC}
  302. PROCEDURE MIDIGetPortName(clientID: OSType; portID: OSType; VAR name: Str255);
  303.     {$IFC NOT GENERATINGCFM}
  304.     INLINE $203C, $0040, 4, $A800;
  305.     {$ENDC}
  306. PROCEDURE MIDISetPortName(clientID: OSType; portID: OSType; name: ConstStr255Param);
  307.     {$IFC NOT GENERATINGCFM}
  308.     INLINE $203C, $0044, 4, $A800;
  309.     {$ENDC}
  310. PROCEDURE MIDIWakeUp(refnum: INTEGER; time: LONGINT; period: LONGINT; timeProc: MIDITimeUPP);
  311.     {$IFC NOT GENERATINGCFM}
  312.     INLINE $203C, $0048, 4, $A800;
  313.     {$ENDC}
  314. PROCEDURE MIDIRemovePort(refnum: INTEGER);
  315.     {$IFC NOT GENERATINGCFM}
  316.     INLINE $203C, $004C, 4, $A800;
  317.     {$ENDC}
  318. FUNCTION MIDIGetSync(refnum: INTEGER): INTEGER;
  319.     {$IFC NOT GENERATINGCFM}
  320.     INLINE $203C, $0050, 4, $A800;
  321.     {$ENDC}
  322. PROCEDURE MIDISetSync(refnum: INTEGER; sync: INTEGER);
  323.     {$IFC NOT GENERATINGCFM}
  324.     INLINE $203C, $0054, 4, $A800;
  325.     {$ENDC}
  326. FUNCTION MIDIGetCurTime(refnum: INTEGER): LONGINT;
  327.     {$IFC NOT GENERATINGCFM}
  328.     INLINE $203C, $0058, 4, $A800;
  329.     {$ENDC}
  330. PROCEDURE MIDISetCurTime(refnum: INTEGER; time: LONGINT);
  331.     {$IFC NOT GENERATINGCFM}
  332.     INLINE $203C, $005C, 4, $A800;
  333.     {$ENDC}
  334. PROCEDURE MIDIStartTime(refnum: INTEGER);
  335.     {$IFC NOT GENERATINGCFM}
  336.     INLINE $203C, $0060, 4, $A800;
  337.     {$ENDC}
  338. PROCEDURE MIDIStopTime(refnum: INTEGER);
  339.     {$IFC NOT GENERATINGCFM}
  340.     INLINE $203C, $0064, 4, $A800;
  341.     {$ENDC}
  342. PROCEDURE MIDIPoll(refnum: INTEGER; offsetTime: LONGINT);
  343.     {$IFC NOT GENERATINGCFM}
  344.     INLINE $203C, $0068, 4, $A800;
  345.     {$ENDC}
  346. FUNCTION MIDIWritePacket(refnum: INTEGER; packet: MIDIPacketPtr): OSErr;
  347.     {$IFC NOT GENERATINGCFM}
  348.     INLINE $203C, $006C, 4, $A800;
  349.     {$ENDC}
  350. FUNCTION MIDIWorldChanged(clientID: OSType): BOOLEAN;
  351.     {$IFC NOT GENERATINGCFM}
  352.     INLINE $203C, $0070, 4, $A800;
  353.     {$ENDC}
  354. FUNCTION MIDIGetOffsetTime(refnum: INTEGER): LONGINT;
  355.     {$IFC NOT GENERATINGCFM}
  356.     INLINE $203C, $0074, 4, $A800;
  357.     {$ENDC}
  358. PROCEDURE MIDISetOffsetTime(refnum: INTEGER; offsetTime: LONGINT);
  359.     {$IFC NOT GENERATINGCFM}
  360.     INLINE $203C, $0078, 4, $A800;
  361.     {$ENDC}
  362. FUNCTION MIDIConvertTime(srcFormat: INTEGER; dstFormat: INTEGER; time: LONGINT): LONGINT;
  363.     {$IFC NOT GENERATINGCFM}
  364.     INLINE $203C, $007C, 4, $A800;
  365.     {$ENDC}
  366. FUNCTION MIDIGetRefCon(refnum: INTEGER): LONGINT;
  367.     {$IFC NOT GENERATINGCFM}
  368.     INLINE $203C, $0080, 4, $A800;
  369.     {$ENDC}
  370. PROCEDURE MIDISetRefCon(refnum: INTEGER; refCon: LONGINT);
  371.     {$IFC NOT GENERATINGCFM}
  372.     INLINE $203C, $0084, 4, $A800;
  373.     {$ENDC}
  374. FUNCTION MIDIGetClRefCon(clientID: OSType): LONGINT;
  375.     {$IFC NOT GENERATINGCFM}
  376.     INLINE $203C, $0088, 4, $A800;
  377.     {$ENDC}
  378. PROCEDURE MIDISetClRefCon(clientID: OSType; refCon: LONGINT);
  379.     {$IFC NOT GENERATINGCFM}
  380.     INLINE $203C, $008C, 4, $A800;
  381.     {$ENDC}
  382. FUNCTION MIDIGetTCFormat(refnum: INTEGER): INTEGER;
  383.     {$IFC NOT GENERATINGCFM}
  384.     INLINE $203C, $0090, 4, $A800;
  385.     {$ENDC}
  386. PROCEDURE MIDISetTCFormat(refnum: INTEGER; format: INTEGER);
  387.     {$IFC NOT GENERATINGCFM}
  388.     INLINE $203C, $0094, 4, $A800;
  389.     {$ENDC}
  390. PROCEDURE MIDISetRunRate(refnum: INTEGER; rate: INTEGER; time: LONGINT);
  391.     {$IFC NOT GENERATINGCFM}
  392.     INLINE $203C, $0098, 4, $A800;
  393.     {$ENDC}
  394. FUNCTION MIDIGetClientIcon(clientID: OSType): Handle;
  395.     {$IFC NOT GENERATINGCFM}
  396.     INLINE $203C, $009C, 4, $A800;
  397.     {$ENDC}
  398. FUNCTION MIDICallAddress(callNum: INTEGER): ProcPtr;
  399.     {$IFC NOT GENERATINGCFM}
  400.     INLINE $203C, 164, 4, $A800;
  401.     {$ENDC}
  402. PROCEDURE MIDISetConnectionProc(refNum: INTEGER; connectionProc: ProcPtr; refCon: LONGINT);
  403.     {$IFC NOT GENERATINGCFM}
  404.     INLINE $203C, 168, 4, $A800;
  405.     {$ENDC}
  406. PROCEDURE MIDIGetConnectionProc(refnum: INTEGER; VAR connectionProc: ProcPtr; VAR refCon: LONGINT);
  407.     {$IFC NOT GENERATINGCFM}
  408.     INLINE $203C, 172, 4, $A800;
  409.     {$ENDC}
  410. PROCEDURE MIDIDiscardPacket(refnum: INTEGER; packet: MIDIPacketPtr);
  411.     {$IFC NOT GENERATINGCFM}
  412.     INLINE $203C, 176, 4, $A800;
  413.     {$ENDC}
  414. FUNCTION MDVRSignIn(clientID: OSType; refCon: LONGINT; icon: Handle; VAR name: Str255): OSErr;
  415.     {$IFC NOT GENERATINGCFM}
  416.     INLINE $203C, 180, 4, $A800;
  417.     {$ENDC}
  418. PROCEDURE MDVRSignOut(clientID: OSType);
  419.     {$IFC NOT GENERATINGCFM}
  420.     INLINE $203C, 184, 4, $A800;
  421.     {$ENDC}
  422. FUNCTION MDVROpen(portType: INTEGER; refnum: INTEGER): MDVRPtr;
  423.     {$IFC NOT GENERATINGCFM}
  424.     INLINE $203C, 188, 4, $A800;
  425.     {$ENDC}
  426. PROCEDURE MDVRClose(driverPtr: MDVRPtr);
  427.     {$IFC NOT GENERATINGCFM}
  428.     INLINE $203C, 192, 4, $A800;
  429.     {$ENDC}
  430. PROCEDURE MDVRControlIn(portPtr: MDVRPtr; inputCtl: MDVRInCtlPtr);
  431.     {$IFC NOT GENERATINGCFM}
  432.     INLINE $203C, 196, 4, $A800;
  433.     {$ENDC}
  434. PROCEDURE MDVRControlOut(portPtr: MDVRPtr; outputCtl: MDVROutCtlPtr);
  435.     {$IFC NOT GENERATINGCFM}
  436.     INLINE $203C, 200, 4, $A800;
  437.     {$ENDC}
  438. PROCEDURE MDVRIn(portPtr: MDVRPtr);
  439.     {$IFC NOT GENERATINGCFM}
  440.     INLINE $203C, 204, 4, $A800;
  441.     {$ENDC}
  442. PROCEDURE MDVROut(portPtr: MDVRPtr; dataPtr: CStringPtr; length: INTEGER);
  443.     {$IFC NOT GENERATINGCFM}
  444.     INLINE $203C, 208, 4, $A800;
  445.     {$ENDC}
  446. PROCEDURE MDVRNotesOff(portPtr: MDVRPtr; mode: INTEGER);
  447.     {$IFC NOT GENERATINGCFM}
  448.     INLINE $203C, 212, 4, $A800;
  449.     {$ENDC}
  450. CONST
  451.     uppMIDIReadHookProcInfo = $000003E0; { FUNCTION (4 byte param, 4 byte param): 2 byte result; }
  452.     uppMIDITimeProcInfo = $000003C0; { PROCEDURE (4 byte param, 4 byte param); }
  453.     uppMIDIConnectionProcInfo = $0009FB80; { PROCEDURE (2 byte param, 4 byte param, 2 byte param, 4 byte param, 4 byte param, 1 byte param, 2 byte param); }
  454.     uppMDVRCommProcInfo = $00000EB0; { FUNCTION (2 byte param, 2 byte param, 4 byte param): 4 byte result; }
  455.     uppMDVRTimeCodeProcInfo = $00000E80; { PROCEDURE (2 byte param, 2 byte param, 4 byte param); }
  456.     uppMDVRReadProcInfo = $00000EC0; { PROCEDURE (4 byte param, 2 byte param, 4 byte param); }
  457.  
  458. FUNCTION NewMIDIReadHookProc(userRoutine: MIDIReadHookProcPtr): MIDIReadHookUPP;
  459.     {$IFC NOT GENERATINGCFM }
  460.     INLINE $2E9F;
  461.     {$ENDC}
  462.  
  463. FUNCTION NewMIDITimeProc(userRoutine: MIDITimeProcPtr): MIDITimeUPP;
  464.     {$IFC NOT GENERATINGCFM }
  465.     INLINE $2E9F;
  466.     {$ENDC}
  467.  
  468. FUNCTION NewMIDIConnectionProc(userRoutine: MIDIConnectionProcPtr): MIDIConnectionUPP;
  469.     {$IFC NOT GENERATINGCFM }
  470.     INLINE $2E9F;
  471.     {$ENDC}
  472.  
  473. FUNCTION NewMDVRCommProc(userRoutine: MDVRCommProcPtr): MDVRCommUPP;
  474.     {$IFC NOT GENERATINGCFM }
  475.     INLINE $2E9F;
  476.     {$ENDC}
  477.  
  478. FUNCTION NewMDVRTimeCodeProc(userRoutine: MDVRTimeCodeProcPtr): MDVRTimeCodeUPP;
  479.     {$IFC NOT GENERATINGCFM }
  480.     INLINE $2E9F;
  481.     {$ENDC}
  482.  
  483. FUNCTION NewMDVRReadProc(userRoutine: MDVRReadProcPtr): MDVRReadUPP;
  484.     {$IFC NOT GENERATINGCFM }
  485.     INLINE $2E9F;
  486.     {$ENDC}
  487.  
  488. FUNCTION CallMIDIReadHookProc(myPacket: MIDIPacketPtr; myRefCon: LONGINT; userRoutine: MIDIReadHookUPP): INTEGER;
  489.     {$IFC NOT GENERATINGCFM}
  490.     INLINE $205F, $4E90;
  491.     {$ENDC}
  492.  
  493. PROCEDURE CallMIDITimeProc(curTime: LONGINT; myRefCon: LONGINT; userRoutine: MIDITimeUPP);
  494.     {$IFC NOT GENERATINGCFM}
  495.     INLINE $205F, $4E90;
  496.     {$ENDC}
  497.  
  498. PROCEDURE CallMIDIConnectionProc(refnum: INTEGER; refcon: LONGINT; portType: INTEGER; clientID: OSType; portID: OSType; connect: BOOLEAN; direction: INTEGER; userRoutine: MIDIConnectionUPP);
  499.     {$IFC NOT GENERATINGCFM}
  500.     INLINE $205F, $4E90;
  501.     {$ENDC}
  502.  
  503. FUNCTION CallMDVRCommProc(refnum: INTEGER; request: INTEGER; refCon: LONGINT; userRoutine: MDVRCommUPP): LONGINT;
  504.     {$IFC NOT GENERATINGCFM}
  505.     INLINE $205F, $4E90;
  506.     {$ENDC}
  507.  
  508. PROCEDURE CallMDVRTimeCodeProc(refnum: INTEGER; newFormat: INTEGER; refCon: LONGINT; userRoutine: MDVRTimeCodeUPP);
  509.     {$IFC NOT GENERATINGCFM}
  510.     INLINE $205F, $4E90;
  511.     {$ENDC}
  512.  
  513. PROCEDURE CallMDVRReadProc(midiChars: CStringPtr; length: INTEGER; refCon: LONGINT; userRoutine: MDVRReadUPP);
  514.     {$IFC NOT GENERATINGCFM}
  515.     INLINE $205F, $4E90;
  516.     {$ENDC}
  517.  
  518. {$ALIGN RESET}
  519. {$POP}
  520.  
  521. {$SETC UsingIncludes := MIDIIncludes}
  522.  
  523. {$ENDC} {__MIDI__}
  524.  
  525. {$IFC NOT UsingIncludes}
  526.  END.
  527. {$ENDC}
  528.